The Runtime Complexity (full) of the given CpxTRS could be proven to be BOUNDS(n^2, INF).

(0) Obligation:

Runtime Complexity TRS:
The TRS R consists of the following rules:

le(0, Y) → true
le(s(X), 0) → false
le(s(X), s(Y)) → le(X, Y)
app(nil, Y) → Y
app(cons(N, L), Y) → cons(N, app(L, Y))
low(N, nil) → nil
low(N, cons(M, L)) → iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) → cons(M, low(N, L))
iflow(false, N, cons(M, L)) → low(N, L)
high(N, nil) → nil
high(N, cons(M, L)) → ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) → high(N, L)
ifhigh(false, N, cons(M, L)) → cons(M, high(N, L))
quicksort(nil) → nil
quicksort(cons(N, L)) → app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Rewrite Strategy: FULL

(1) DecreasingLoopProof (EQUIVALENT transformation)

The following loop(s) give(s) rise to the lower bound Ω(n¹):
The rewrite sequence
le(s(X), s(Y)) →⁺ le(X, Y)
gives rise to a decreasing loop by considering the right hand sides subterm at position [].
The pumping substitution is [X / s(X), Y / s(Y)].
The result substitution is [ ].

(2) BOUNDS(n^1, INF)

(3) RenamingProof (EQUIVALENT transformation)

Renamed function symbols to avoid clashes with predefined symbol.

(4) Obligation:

Runtime Complexity Relative TRS:
The TRS R consists of the following rules:

le(0', Y) → true
le(s(X), 0') → false
le(s(X), s(Y)) → le(X, Y)
app(nil, Y) → Y
app(cons(N, L), Y) → cons(N, app(L, Y))
low(N, nil) → nil
low(N, cons(M, L)) → iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) → cons(M, low(N, L))
iflow(false, N, cons(M, L)) → low(N, L)
high(N, nil) → nil
high(N, cons(M, L)) → ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) → high(N, L)
ifhigh(false, N, cons(M, L)) → cons(M, high(N, L))
quicksort(nil) → nil
quicksort(cons(N, L)) → app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

S is empty.
Rewrite Strategy: FULL

(5) TypeInferenceProof (BOTH BOUNDS(ID, ID) transformation)

Infered types.

(6) Obligation:

TRS:
Rules:
le(0', Y) → true
le(s(X), 0') → false
le(s(X), s(Y)) → le(X, Y)
app(nil, Y) → Y
app(cons(N, L), Y) → cons(N, app(L, Y))
low(N, nil) → nil
low(N, cons(M, L)) → iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) → cons(M, low(N, L))
iflow(false, N, cons(M, L)) → low(N, L)
high(N, nil) → nil
high(N, cons(M, L)) → ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) → high(N, L)
ifhigh(false, N, cons(M, L)) → cons(M, high(N, L))
quicksort(nil) → nil
quicksort(cons(N, L)) → app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Types:
le :: 0':s → 0':s → true:false
0' :: 0':s
true :: true:false
s :: 0':s → 0':s
false :: true:false
app :: nil:cons → nil:cons → nil:cons
nil :: nil:cons
cons :: 0':s → nil:cons → nil:cons
low :: 0':s → nil:cons → nil:cons
iflow :: true:false → 0':s → nil:cons → nil:cons
high :: 0':s → nil:cons → nil:cons
ifhigh :: true:false → 0':s → nil:cons → nil:cons
quicksort :: nil:cons → nil:cons
hole_true:false1_0 :: true:false
hole_0':s2_0 :: 0':s
hole_nil:cons3_0 :: nil:cons
gen_0':s4_0 :: Nat → 0':s
gen_nil:cons5_0 :: Nat → nil:cons

(7) OrderProof (LOWER BOUND(ID) transformation)

Heuristically decided to analyse the following defined symbols:
le, app, low, high, quicksort

They will be analysed ascendingly in the following order:
le < low
le < high
app < quicksort
low < quicksort
high < quicksort

(8) Obligation:

TRS:
Rules:
le(0', Y) → true
le(s(X), 0') → false
le(s(X), s(Y)) → le(X, Y)
app(nil, Y) → Y
app(cons(N, L), Y) → cons(N, app(L, Y))
low(N, nil) → nil
low(N, cons(M, L)) → iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) → cons(M, low(N, L))
iflow(false, N, cons(M, L)) → low(N, L)
high(N, nil) → nil
high(N, cons(M, L)) → ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) → high(N, L)
ifhigh(false, N, cons(M, L)) → cons(M, high(N, L))
quicksort(nil) → nil
quicksort(cons(N, L)) → app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Types:
le :: 0':s → 0':s → true:false
0' :: 0':s
true :: true:false
s :: 0':s → 0':s
false :: true:false
app :: nil:cons → nil:cons → nil:cons
nil :: nil:cons
cons :: 0':s → nil:cons → nil:cons
low :: 0':s → nil:cons → nil:cons
iflow :: true:false → 0':s → nil:cons → nil:cons
high :: 0':s → nil:cons → nil:cons
ifhigh :: true:false → 0':s → nil:cons → nil:cons
quicksort :: nil:cons → nil:cons
hole_true:false1_0 :: true:false
hole_0':s2_0 :: 0':s
hole_nil:cons3_0 :: nil:cons
gen_0':s4_0 :: Nat → 0':s
gen_nil:cons5_0 :: Nat → nil:cons

Generator Equations:
gen_0':s4_0(0) ⇔ 0'
gen_0':s4_0(+(x, 1)) ⇔ s(gen_0':s4_0(x))
gen_nil:cons5_0(0) ⇔ nil
gen_nil:cons5_0(+(x, 1)) ⇔ cons(0', gen_nil:cons5_0(x))

The following defined symbols remain to be analysed:
le, app, low, high, quicksort

They will be analysed ascendingly in the following order:
le < low
le < high
app < quicksort
low < quicksort
high < quicksort

(9) RewriteLemmaProof (LOWER BOUND(ID) transformation)

Proved the following rewrite lemma:
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) → true, rt ∈ Ω(1 + n7₀)

Induction Base:
le(gen_0':s4_0(0), gen_0':s4_0(0)) →_R^Ω(1)
true

Induction Step:
le(gen_0':s4_0(+(n7_0, 1)), gen_0':s4_0(+(n7_0, 1))) →_R^Ω(1)
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) →_IH
true

We have rt ∈ Ω(n¹) and sz ∈ O(n). Thus, we have irc_R ∈ Ω(n).

(10) Complex Obligation (BEST)

(11) Obligation:

TRS:
Rules:
le(0', Y) → true
le(s(X), 0') → false
le(s(X), s(Y)) → le(X, Y)
app(nil, Y) → Y
app(cons(N, L), Y) → cons(N, app(L, Y))
low(N, nil) → nil
low(N, cons(M, L)) → iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) → cons(M, low(N, L))
iflow(false, N, cons(M, L)) → low(N, L)
high(N, nil) → nil
high(N, cons(M, L)) → ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) → high(N, L)
ifhigh(false, N, cons(M, L)) → cons(M, high(N, L))
quicksort(nil) → nil
quicksort(cons(N, L)) → app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Types:
le :: 0':s → 0':s → true:false
0' :: 0':s
true :: true:false
s :: 0':s → 0':s
false :: true:false
app :: nil:cons → nil:cons → nil:cons
nil :: nil:cons
cons :: 0':s → nil:cons → nil:cons
low :: 0':s → nil:cons → nil:cons
iflow :: true:false → 0':s → nil:cons → nil:cons
high :: 0':s → nil:cons → nil:cons
ifhigh :: true:false → 0':s → nil:cons → nil:cons
quicksort :: nil:cons → nil:cons
hole_true:false1_0 :: true:false
hole_0':s2_0 :: 0':s
hole_nil:cons3_0 :: nil:cons
gen_0':s4_0 :: Nat → 0':s
gen_nil:cons5_0 :: Nat → nil:cons

Lemmas:
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) → true, rt ∈ Ω(1 + n7₀)

Generator Equations:
gen_0':s4_0(0) ⇔ 0'
gen_0':s4_0(+(x, 1)) ⇔ s(gen_0':s4_0(x))
gen_nil:cons5_0(0) ⇔ nil
gen_nil:cons5_0(+(x, 1)) ⇔ cons(0', gen_nil:cons5_0(x))

The following defined symbols remain to be analysed:
app, low, high, quicksort

They will be analysed ascendingly in the following order:
app < quicksort
low < quicksort
high < quicksort

(12) RewriteLemmaProof (LOWER BOUND(ID) transformation)

Proved the following rewrite lemma:
app(gen_nil:cons5_0(n312_0), gen_nil:cons5_0(b)) → gen_nil:cons5_0(+(n312_0, b)), rt ∈ Ω(1 + n312₀)

Induction Base:
app(gen_nil:cons5_0(0), gen_nil:cons5_0(b)) →_R^Ω(1)
gen_nil:cons5_0(b)

Induction Step:
app(gen_nil:cons5_0(+(n312_0, 1)), gen_nil:cons5_0(b)) →_R^Ω(1)
cons(0', app(gen_nil:cons5_0(n312_0), gen_nil:cons5_0(b))) →_IH
cons(0', gen_nil:cons5_0(+(b, c313_0)))

We have rt ∈ Ω(n¹) and sz ∈ O(n). Thus, we have irc_R ∈ Ω(n).

(13) Complex Obligation (BEST)

(14) Obligation:

TRS:
Rules:
le(0', Y) → true
le(s(X), 0') → false
le(s(X), s(Y)) → le(X, Y)
app(nil, Y) → Y
app(cons(N, L), Y) → cons(N, app(L, Y))
low(N, nil) → nil
low(N, cons(M, L)) → iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) → cons(M, low(N, L))
iflow(false, N, cons(M, L)) → low(N, L)
high(N, nil) → nil
high(N, cons(M, L)) → ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) → high(N, L)
ifhigh(false, N, cons(M, L)) → cons(M, high(N, L))
quicksort(nil) → nil
quicksort(cons(N, L)) → app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Types:
le :: 0':s → 0':s → true:false
0' :: 0':s
true :: true:false
s :: 0':s → 0':s
false :: true:false
app :: nil:cons → nil:cons → nil:cons
nil :: nil:cons
cons :: 0':s → nil:cons → nil:cons
low :: 0':s → nil:cons → nil:cons
iflow :: true:false → 0':s → nil:cons → nil:cons
high :: 0':s → nil:cons → nil:cons
ifhigh :: true:false → 0':s → nil:cons → nil:cons
quicksort :: nil:cons → nil:cons
hole_true:false1_0 :: true:false
hole_0':s2_0 :: 0':s
hole_nil:cons3_0 :: nil:cons
gen_0':s4_0 :: Nat → 0':s
gen_nil:cons5_0 :: Nat → nil:cons

Lemmas:
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) → true, rt ∈ Ω(1 + n7₀)
app(gen_nil:cons5_0(n312_0), gen_nil:cons5_0(b)) → gen_nil:cons5_0(+(n312_0, b)), rt ∈ Ω(1 + n312₀)

Generator Equations:
gen_0':s4_0(0) ⇔ 0'
gen_0':s4_0(+(x, 1)) ⇔ s(gen_0':s4_0(x))
gen_nil:cons5_0(0) ⇔ nil
gen_nil:cons5_0(+(x, 1)) ⇔ cons(0', gen_nil:cons5_0(x))

The following defined symbols remain to be analysed:
low, high, quicksort

They will be analysed ascendingly in the following order:
low < quicksort
high < quicksort

(15) RewriteLemmaProof (LOWER BOUND(ID) transformation)

Proved the following rewrite lemma:
low(gen_0':s4_0(0), gen_nil:cons5_0(n1147_0)) → gen_nil:cons5_0(n1147_0), rt ∈ Ω(1 + n1147₀)

Induction Base:
low(gen_0':s4_0(0), gen_nil:cons5_0(0)) →_R^Ω(1)
nil

Induction Step:
low(gen_0':s4_0(0), gen_nil:cons5_0(+(n1147_0, 1))) →_R^Ω(1)
iflow(le(0', gen_0':s4_0(0)), gen_0':s4_0(0), cons(0', gen_nil:cons5_0(n1147_0))) →_L^Ω(1)
iflow(true, gen_0':s4_0(0), cons(0', gen_nil:cons5_0(n1147_0))) →_R^Ω(1)
cons(0', low(gen_0':s4_0(0), gen_nil:cons5_0(n1147_0))) →_IH
cons(0', gen_nil:cons5_0(c1148_0))

We have rt ∈ Ω(n¹) and sz ∈ O(n). Thus, we have irc_R ∈ Ω(n).

(16) Complex Obligation (BEST)

(17) Obligation:

TRS:
Rules:
le(0', Y) → true
le(s(X), 0') → false
le(s(X), s(Y)) → le(X, Y)
app(nil, Y) → Y
app(cons(N, L), Y) → cons(N, app(L, Y))
low(N, nil) → nil
low(N, cons(M, L)) → iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) → cons(M, low(N, L))
iflow(false, N, cons(M, L)) → low(N, L)
high(N, nil) → nil
high(N, cons(M, L)) → ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) → high(N, L)
ifhigh(false, N, cons(M, L)) → cons(M, high(N, L))
quicksort(nil) → nil
quicksort(cons(N, L)) → app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Types:
le :: 0':s → 0':s → true:false
0' :: 0':s
true :: true:false
s :: 0':s → 0':s
false :: true:false
app :: nil:cons → nil:cons → nil:cons
nil :: nil:cons
cons :: 0':s → nil:cons → nil:cons
low :: 0':s → nil:cons → nil:cons
iflow :: true:false → 0':s → nil:cons → nil:cons
high :: 0':s → nil:cons → nil:cons
ifhigh :: true:false → 0':s → nil:cons → nil:cons
quicksort :: nil:cons → nil:cons
hole_true:false1_0 :: true:false
hole_0':s2_0 :: 0':s
hole_nil:cons3_0 :: nil:cons
gen_0':s4_0 :: Nat → 0':s
gen_nil:cons5_0 :: Nat → nil:cons

Lemmas:
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) → true, rt ∈ Ω(1 + n7₀)
app(gen_nil:cons5_0(n312_0), gen_nil:cons5_0(b)) → gen_nil:cons5_0(+(n312_0, b)), rt ∈ Ω(1 + n312₀)
low(gen_0':s4_0(0), gen_nil:cons5_0(n1147_0)) → gen_nil:cons5_0(n1147_0), rt ∈ Ω(1 + n1147₀)

Generator Equations:
gen_0':s4_0(0) ⇔ 0'
gen_0':s4_0(+(x, 1)) ⇔ s(gen_0':s4_0(x))
gen_nil:cons5_0(0) ⇔ nil
gen_nil:cons5_0(+(x, 1)) ⇔ cons(0', gen_nil:cons5_0(x))

The following defined symbols remain to be analysed:
high, quicksort

They will be analysed ascendingly in the following order:
high < quicksort

(18) RewriteLemmaProof (LOWER BOUND(ID) transformation)

Proved the following rewrite lemma:
high(gen_0':s4_0(0), gen_nil:cons5_0(n1656_0)) → gen_nil:cons5_0(0), rt ∈ Ω(1 + n1656₀)

Induction Base:
high(gen_0':s4_0(0), gen_nil:cons5_0(0)) →_R^Ω(1)
nil

Induction Step:
high(gen_0':s4_0(0), gen_nil:cons5_0(+(n1656_0, 1))) →_R^Ω(1)
ifhigh(le(0', gen_0':s4_0(0)), gen_0':s4_0(0), cons(0', gen_nil:cons5_0(n1656_0))) →_L^Ω(1)
ifhigh(true, gen_0':s4_0(0), cons(0', gen_nil:cons5_0(n1656_0))) →_R^Ω(1)
high(gen_0':s4_0(0), gen_nil:cons5_0(n1656_0)) →_IH
gen_nil:cons5_0(0)

We have rt ∈ Ω(n¹) and sz ∈ O(n). Thus, we have irc_R ∈ Ω(n).

(19) Complex Obligation (BEST)

(20) Obligation:

TRS:
Rules:
le(0', Y) → true
le(s(X), 0') → false
le(s(X), s(Y)) → le(X, Y)
app(nil, Y) → Y
app(cons(N, L), Y) → cons(N, app(L, Y))
low(N, nil) → nil
low(N, cons(M, L)) → iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) → cons(M, low(N, L))
iflow(false, N, cons(M, L)) → low(N, L)
high(N, nil) → nil
high(N, cons(M, L)) → ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) → high(N, L)
ifhigh(false, N, cons(M, L)) → cons(M, high(N, L))
quicksort(nil) → nil
quicksort(cons(N, L)) → app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Types:
le :: 0':s → 0':s → true:false
0' :: 0':s
true :: true:false
s :: 0':s → 0':s
false :: true:false
app :: nil:cons → nil:cons → nil:cons
nil :: nil:cons
cons :: 0':s → nil:cons → nil:cons
low :: 0':s → nil:cons → nil:cons
iflow :: true:false → 0':s → nil:cons → nil:cons
high :: 0':s → nil:cons → nil:cons
ifhigh :: true:false → 0':s → nil:cons → nil:cons
quicksort :: nil:cons → nil:cons
hole_true:false1_0 :: true:false
hole_0':s2_0 :: 0':s
hole_nil:cons3_0 :: nil:cons
gen_0':s4_0 :: Nat → 0':s
gen_nil:cons5_0 :: Nat → nil:cons

Lemmas:
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) → true, rt ∈ Ω(1 + n7₀)
app(gen_nil:cons5_0(n312_0), gen_nil:cons5_0(b)) → gen_nil:cons5_0(+(n312_0, b)), rt ∈ Ω(1 + n312₀)
low(gen_0':s4_0(0), gen_nil:cons5_0(n1147_0)) → gen_nil:cons5_0(n1147_0), rt ∈ Ω(1 + n1147₀)
high(gen_0':s4_0(0), gen_nil:cons5_0(n1656_0)) → gen_nil:cons5_0(0), rt ∈ Ω(1 + n1656₀)

Generator Equations:
gen_0':s4_0(0) ⇔ 0'
gen_0':s4_0(+(x, 1)) ⇔ s(gen_0':s4_0(x))
gen_nil:cons5_0(0) ⇔ nil
gen_nil:cons5_0(+(x, 1)) ⇔ cons(0', gen_nil:cons5_0(x))

The following defined symbols remain to be analysed:
quicksort

(21) RewriteLemmaProof (LOWER BOUND(ID) transformation)

Proved the following rewrite lemma:
quicksort(gen_nil:cons5_0(n2161_0)) → gen_nil:cons5_0(n2161_0), rt ∈ Ω(1 + n2161₀ + n2161₀²)

Induction Base:
quicksort(gen_nil:cons5_0(0)) →_R^Ω(1)
nil

Induction Step:
quicksort(gen_nil:cons5_0(+(n2161_0, 1))) →_R^Ω(1)
app(quicksort(low(0', gen_nil:cons5_0(n2161_0))), cons(0', quicksort(high(0', gen_nil:cons5_0(n2161_0))))) →_L^{Ω(1 + n2161₀)}
app(quicksort(gen_nil:cons5_0(n2161_0)), cons(0', quicksort(high(0', gen_nil:cons5_0(n2161_0))))) →_IH
app(gen_nil:cons5_0(c2162_0), cons(0', quicksort(high(0', gen_nil:cons5_0(n2161_0))))) →_L^{Ω(1 + n2161₀)}
app(gen_nil:cons5_0(n2161_0), cons(0', quicksort(gen_nil:cons5_0(0)))) →_R^Ω(1)
app(gen_nil:cons5_0(n2161_0), cons(0', nil)) →_L^{Ω(1 + n2161₀)}
gen_nil:cons5_0(+(n2161_0, +(0, 1)))

We have rt ∈ Ω(n²) and sz ∈ O(n). Thus, we have irc_R ∈ Ω(n²).

(22) Complex Obligation (BEST)

(23) Obligation:

TRS:
Rules:
le(0', Y) → true
le(s(X), 0') → false
le(s(X), s(Y)) → le(X, Y)
app(nil, Y) → Y
app(cons(N, L), Y) → cons(N, app(L, Y))
low(N, nil) → nil
low(N, cons(M, L)) → iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) → cons(M, low(N, L))
iflow(false, N, cons(M, L)) → low(N, L)
high(N, nil) → nil
high(N, cons(M, L)) → ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) → high(N, L)
ifhigh(false, N, cons(M, L)) → cons(M, high(N, L))
quicksort(nil) → nil
quicksort(cons(N, L)) → app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Types:
le :: 0':s → 0':s → true:false
0' :: 0':s
true :: true:false
s :: 0':s → 0':s
false :: true:false
app :: nil:cons → nil:cons → nil:cons
nil :: nil:cons
cons :: 0':s → nil:cons → nil:cons
low :: 0':s → nil:cons → nil:cons
iflow :: true:false → 0':s → nil:cons → nil:cons
high :: 0':s → nil:cons → nil:cons
ifhigh :: true:false → 0':s → nil:cons → nil:cons
quicksort :: nil:cons → nil:cons
hole_true:false1_0 :: true:false
hole_0':s2_0 :: 0':s
hole_nil:cons3_0 :: nil:cons
gen_0':s4_0 :: Nat → 0':s
gen_nil:cons5_0 :: Nat → nil:cons

Lemmas:
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) → true, rt ∈ Ω(1 + n7₀)
app(gen_nil:cons5_0(n312_0), gen_nil:cons5_0(b)) → gen_nil:cons5_0(+(n312_0, b)), rt ∈ Ω(1 + n312₀)
low(gen_0':s4_0(0), gen_nil:cons5_0(n1147_0)) → gen_nil:cons5_0(n1147_0), rt ∈ Ω(1 + n1147₀)
high(gen_0':s4_0(0), gen_nil:cons5_0(n1656_0)) → gen_nil:cons5_0(0), rt ∈ Ω(1 + n1656₀)
quicksort(gen_nil:cons5_0(n2161_0)) → gen_nil:cons5_0(n2161_0), rt ∈ Ω(1 + n2161₀ + n2161₀²)

Generator Equations:
gen_0':s4_0(0) ⇔ 0'
gen_0':s4_0(+(x, 1)) ⇔ s(gen_0':s4_0(x))
gen_nil:cons5_0(0) ⇔ nil
gen_nil:cons5_0(+(x, 1)) ⇔ cons(0', gen_nil:cons5_0(x))

No more defined symbols left to analyse.

(24) LowerBoundsProof (EQUIVALENT transformation)

The lowerbound Ω(n²) was proven with the following lemma:
quicksort(gen_nil:cons5_0(n2161_0)) → gen_nil:cons5_0(n2161_0), rt ∈ Ω(1 + n2161₀ + n2161₀²)

(25) BOUNDS(n^2, INF)

(26) Obligation:

TRS:
Rules:
le(0', Y) → true
le(s(X), 0') → false
le(s(X), s(Y)) → le(X, Y)
app(nil, Y) → Y
app(cons(N, L), Y) → cons(N, app(L, Y))
low(N, nil) → nil
low(N, cons(M, L)) → iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) → cons(M, low(N, L))
iflow(false, N, cons(M, L)) → low(N, L)
high(N, nil) → nil
high(N, cons(M, L)) → ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) → high(N, L)
ifhigh(false, N, cons(M, L)) → cons(M, high(N, L))
quicksort(nil) → nil
quicksort(cons(N, L)) → app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Types:
le :: 0':s → 0':s → true:false
0' :: 0':s
true :: true:false
s :: 0':s → 0':s
false :: true:false
app :: nil:cons → nil:cons → nil:cons
nil :: nil:cons
cons :: 0':s → nil:cons → nil:cons
low :: 0':s → nil:cons → nil:cons
iflow :: true:false → 0':s → nil:cons → nil:cons
high :: 0':s → nil:cons → nil:cons
ifhigh :: true:false → 0':s → nil:cons → nil:cons
quicksort :: nil:cons → nil:cons
hole_true:false1_0 :: true:false
hole_0':s2_0 :: 0':s
hole_nil:cons3_0 :: nil:cons
gen_0':s4_0 :: Nat → 0':s
gen_nil:cons5_0 :: Nat → nil:cons

Lemmas:
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) → true, rt ∈ Ω(1 + n7₀)
app(gen_nil:cons5_0(n312_0), gen_nil:cons5_0(b)) → gen_nil:cons5_0(+(n312_0, b)), rt ∈ Ω(1 + n312₀)
low(gen_0':s4_0(0), gen_nil:cons5_0(n1147_0)) → gen_nil:cons5_0(n1147_0), rt ∈ Ω(1 + n1147₀)
high(gen_0':s4_0(0), gen_nil:cons5_0(n1656_0)) → gen_nil:cons5_0(0), rt ∈ Ω(1 + n1656₀)
quicksort(gen_nil:cons5_0(n2161_0)) → gen_nil:cons5_0(n2161_0), rt ∈ Ω(1 + n2161₀ + n2161₀²)

Generator Equations:
gen_0':s4_0(0) ⇔ 0'
gen_0':s4_0(+(x, 1)) ⇔ s(gen_0':s4_0(x))
gen_nil:cons5_0(0) ⇔ nil
gen_nil:cons5_0(+(x, 1)) ⇔ cons(0', gen_nil:cons5_0(x))

No more defined symbols left to analyse.

(27) LowerBoundsProof (EQUIVALENT transformation)

The lowerbound Ω(n²) was proven with the following lemma:
quicksort(gen_nil:cons5_0(n2161_0)) → gen_nil:cons5_0(n2161_0), rt ∈ Ω(1 + n2161₀ + n2161₀²)

(28) BOUNDS(n^2, INF)

(29) Obligation:

TRS:
Rules:
le(0', Y) → true
le(s(X), 0') → false
le(s(X), s(Y)) → le(X, Y)
app(nil, Y) → Y
app(cons(N, L), Y) → cons(N, app(L, Y))
low(N, nil) → nil
low(N, cons(M, L)) → iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) → cons(M, low(N, L))
iflow(false, N, cons(M, L)) → low(N, L)
high(N, nil) → nil
high(N, cons(M, L)) → ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) → high(N, L)
ifhigh(false, N, cons(M, L)) → cons(M, high(N, L))
quicksort(nil) → nil
quicksort(cons(N, L)) → app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Types:
le :: 0':s → 0':s → true:false
0' :: 0':s
true :: true:false
s :: 0':s → 0':s
false :: true:false
app :: nil:cons → nil:cons → nil:cons
nil :: nil:cons
cons :: 0':s → nil:cons → nil:cons
low :: 0':s → nil:cons → nil:cons
iflow :: true:false → 0':s → nil:cons → nil:cons
high :: 0':s → nil:cons → nil:cons
ifhigh :: true:false → 0':s → nil:cons → nil:cons
quicksort :: nil:cons → nil:cons
hole_true:false1_0 :: true:false
hole_0':s2_0 :: 0':s
hole_nil:cons3_0 :: nil:cons
gen_0':s4_0 :: Nat → 0':s
gen_nil:cons5_0 :: Nat → nil:cons

Lemmas:
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) → true, rt ∈ Ω(1 + n7₀)
app(gen_nil:cons5_0(n312_0), gen_nil:cons5_0(b)) → gen_nil:cons5_0(+(n312_0, b)), rt ∈ Ω(1 + n312₀)
low(gen_0':s4_0(0), gen_nil:cons5_0(n1147_0)) → gen_nil:cons5_0(n1147_0), rt ∈ Ω(1 + n1147₀)
high(gen_0':s4_0(0), gen_nil:cons5_0(n1656_0)) → gen_nil:cons5_0(0), rt ∈ Ω(1 + n1656₀)

Generator Equations:
gen_0':s4_0(0) ⇔ 0'
gen_0':s4_0(+(x, 1)) ⇔ s(gen_0':s4_0(x))
gen_nil:cons5_0(0) ⇔ nil
gen_nil:cons5_0(+(x, 1)) ⇔ cons(0', gen_nil:cons5_0(x))

No more defined symbols left to analyse.

(30) LowerBoundsProof (EQUIVALENT transformation)

The lowerbound Ω(n¹) was proven with the following lemma:
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) → true, rt ∈ Ω(1 + n7₀)

(31) BOUNDS(n^1, INF)

(32) Obligation:

TRS:
Rules:
le(0', Y) → true
le(s(X), 0') → false
le(s(X), s(Y)) → le(X, Y)
app(nil, Y) → Y
app(cons(N, L), Y) → cons(N, app(L, Y))
low(N, nil) → nil
low(N, cons(M, L)) → iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) → cons(M, low(N, L))
iflow(false, N, cons(M, L)) → low(N, L)
high(N, nil) → nil
high(N, cons(M, L)) → ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) → high(N, L)
ifhigh(false, N, cons(M, L)) → cons(M, high(N, L))
quicksort(nil) → nil
quicksort(cons(N, L)) → app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Types:
le :: 0':s → 0':s → true:false
0' :: 0':s
true :: true:false
s :: 0':s → 0':s
false :: true:false
app :: nil:cons → nil:cons → nil:cons
nil :: nil:cons
cons :: 0':s → nil:cons → nil:cons
low :: 0':s → nil:cons → nil:cons
iflow :: true:false → 0':s → nil:cons → nil:cons
high :: 0':s → nil:cons → nil:cons
ifhigh :: true:false → 0':s → nil:cons → nil:cons
quicksort :: nil:cons → nil:cons
hole_true:false1_0 :: true:false
hole_0':s2_0 :: 0':s
hole_nil:cons3_0 :: nil:cons
gen_0':s4_0 :: Nat → 0':s
gen_nil:cons5_0 :: Nat → nil:cons

Lemmas:
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) → true, rt ∈ Ω(1 + n7₀)
app(gen_nil:cons5_0(n312_0), gen_nil:cons5_0(b)) → gen_nil:cons5_0(+(n312_0, b)), rt ∈ Ω(1 + n312₀)
low(gen_0':s4_0(0), gen_nil:cons5_0(n1147_0)) → gen_nil:cons5_0(n1147_0), rt ∈ Ω(1 + n1147₀)

Generator Equations:
gen_0':s4_0(0) ⇔ 0'
gen_0':s4_0(+(x, 1)) ⇔ s(gen_0':s4_0(x))
gen_nil:cons5_0(0) ⇔ nil
gen_nil:cons5_0(+(x, 1)) ⇔ cons(0', gen_nil:cons5_0(x))

No more defined symbols left to analyse.

(33) LowerBoundsProof (EQUIVALENT transformation)

The lowerbound Ω(n¹) was proven with the following lemma:
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) → true, rt ∈ Ω(1 + n7₀)

(34) BOUNDS(n^1, INF)

(35) Obligation:

TRS:
Rules:
le(0', Y) → true
le(s(X), 0') → false
le(s(X), s(Y)) → le(X, Y)
app(nil, Y) → Y
app(cons(N, L), Y) → cons(N, app(L, Y))
low(N, nil) → nil
low(N, cons(M, L)) → iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) → cons(M, low(N, L))
iflow(false, N, cons(M, L)) → low(N, L)
high(N, nil) → nil
high(N, cons(M, L)) → ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) → high(N, L)
ifhigh(false, N, cons(M, L)) → cons(M, high(N, L))
quicksort(nil) → nil
quicksort(cons(N, L)) → app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Types:
le :: 0':s → 0':s → true:false
0' :: 0':s
true :: true:false
s :: 0':s → 0':s
false :: true:false
app :: nil:cons → nil:cons → nil:cons
nil :: nil:cons
cons :: 0':s → nil:cons → nil:cons
low :: 0':s → nil:cons → nil:cons
iflow :: true:false → 0':s → nil:cons → nil:cons
high :: 0':s → nil:cons → nil:cons
ifhigh :: true:false → 0':s → nil:cons → nil:cons
quicksort :: nil:cons → nil:cons
hole_true:false1_0 :: true:false
hole_0':s2_0 :: 0':s
hole_nil:cons3_0 :: nil:cons
gen_0':s4_0 :: Nat → 0':s
gen_nil:cons5_0 :: Nat → nil:cons

Lemmas:
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) → true, rt ∈ Ω(1 + n7₀)
app(gen_nil:cons5_0(n312_0), gen_nil:cons5_0(b)) → gen_nil:cons5_0(+(n312_0, b)), rt ∈ Ω(1 + n312₀)

Generator Equations:
gen_0':s4_0(0) ⇔ 0'
gen_0':s4_0(+(x, 1)) ⇔ s(gen_0':s4_0(x))
gen_nil:cons5_0(0) ⇔ nil
gen_nil:cons5_0(+(x, 1)) ⇔ cons(0', gen_nil:cons5_0(x))

No more defined symbols left to analyse.

(36) LowerBoundsProof (EQUIVALENT transformation)

The lowerbound Ω(n¹) was proven with the following lemma:
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) → true, rt ∈ Ω(1 + n7₀)

(37) BOUNDS(n^1, INF)

(38) Obligation:

TRS:
Rules:
le(0', Y) → true
le(s(X), 0') → false
le(s(X), s(Y)) → le(X, Y)
app(nil, Y) → Y
app(cons(N, L), Y) → cons(N, app(L, Y))
low(N, nil) → nil
low(N, cons(M, L)) → iflow(le(M, N), N, cons(M, L))
iflow(true, N, cons(M, L)) → cons(M, low(N, L))
iflow(false, N, cons(M, L)) → low(N, L)
high(N, nil) → nil
high(N, cons(M, L)) → ifhigh(le(M, N), N, cons(M, L))
ifhigh(true, N, cons(M, L)) → high(N, L)
ifhigh(false, N, cons(M, L)) → cons(M, high(N, L))
quicksort(nil) → nil
quicksort(cons(N, L)) → app(quicksort(low(N, L)), cons(N, quicksort(high(N, L))))

Types:
le :: 0':s → 0':s → true:false
0' :: 0':s
true :: true:false
s :: 0':s → 0':s
false :: true:false
app :: nil:cons → nil:cons → nil:cons
nil :: nil:cons
cons :: 0':s → nil:cons → nil:cons
low :: 0':s → nil:cons → nil:cons
iflow :: true:false → 0':s → nil:cons → nil:cons
high :: 0':s → nil:cons → nil:cons
ifhigh :: true:false → 0':s → nil:cons → nil:cons
quicksort :: nil:cons → nil:cons
hole_true:false1_0 :: true:false
hole_0':s2_0 :: 0':s
hole_nil:cons3_0 :: nil:cons
gen_0':s4_0 :: Nat → 0':s
gen_nil:cons5_0 :: Nat → nil:cons

Lemmas:
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) → true, rt ∈ Ω(1 + n7₀)

Generator Equations:
gen_0':s4_0(0) ⇔ 0'
gen_0':s4_0(+(x, 1)) ⇔ s(gen_0':s4_0(x))
gen_nil:cons5_0(0) ⇔ nil
gen_nil:cons5_0(+(x, 1)) ⇔ cons(0', gen_nil:cons5_0(x))

No more defined symbols left to analyse.

(39) LowerBoundsProof (EQUIVALENT transformation)

The lowerbound Ω(n¹) was proven with the following lemma:
le(gen_0':s4_0(n7_0), gen_0':s4_0(n7_0)) → true, rt ∈ Ω(1 + n7₀)

(40) BOUNDS(n^1, INF)